use std::rc::Rc;

fn use_rc_demo1() {
    let f = Rc::new(vec![1, 2, 3]);
    let b = f.clone();
    let c = f.clone();

    println!("{:?}", b);
    println!("{:?}", c);
    // 我们创建了一个Rc，然后克隆了它两次。
    // a和b都是foo的克隆，它们指向同一个内存地址。
    // 因为Rc只提供对其包装的数据的只读访问，所以我们不能通过a或b来修改数据
}

// 查看Rc结构发生clone的时候，各个值的指向
fn use_rc_demo2() {
    let data = Rc::new(vec![1, 2, 3]);
    let data_clone = Rc::clone(&data);

    println!("{:?}", *data);
    println!("{:?}", *data_clone);
}
/*
RC结构通过引用计数的方式，控制一个值的引用次数，属于智能指针。
一个Rc智能指针控制的变量，允许多个所有者共享同一份数据，而不需要复制。每一次clone都只是将rc智能指针的引用数+1

一般来说，如果执行clone，都是深拷贝，但是rc结构的clone是浅拷贝，
在这种情况下，clone方法会创建一个新的智能指针，指向同一个对象，并增加引用计数，而不是复制整个对象。这被称为浅拷贝。
*/
fn main() {
    println!("简单查看rc的clone:");
    use_rc_demo1(); // 将rc结构clone
    println!("通过地址看Rc的clone");
    use_rc_demo2();
    println!("通过arc智能指针修改Rc结构");
    use_arc_demo1();
    println!("在多个线程中修改Arc的值");
    use_arc_demo2();
}

use std::cell::RefCell;

fn use_arc_demo1() {
    let data = Rc::new(RefCell::new(vec![1, 2, 3, 4]));
    let a = data.clone();
    let b = data.clone();

    // 开始修改Rc结构的值内容
    // 本身Rc是不可变的，里面组合了RefCell，自然就调用了对应的方法
    // 将引用借用了出来。
    // 使用RefCell来提供内部可变性，这样就可以修改a、b的数据了。
    a.borrow_mut().push(666);

    println!("{:?}", a);
    println!("{:?}", b);
}

use std::sync::Arc;
use std::{thread, vec};
fn use_arc_demo2() {
    let data = Arc::new(vec![1, 2, 3]);
    let data_clone = Arc::clone(&data);

    let handle = thread::spawn(move || {
        println!("{:?}", *data_clone);
    });

    println!("{:?}", *data);

    handle.join().unwrap();
}
